/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.cast.s3p.persistencia;

import com.cast.s3p.persistencia.exceptions.IllegalOrphanException;
import com.cast.s3p.persistencia.exceptions.NonexistentEntityException;
import com.cast.s3p.persistencia.exceptions.PreexistingEntityException;
import java.io.Serializable;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.Collection;
import javax.persistence.Persistence;

/**
 *
 * @author edgarin
 */
public class EvaluadorJpaController implements Serializable {

    public EvaluadorJpaController() {
        this.emf = Persistence.createEntityManagerFactory("s3pPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Evaluador evaluador) throws PreexistingEntityException, Exception {
        if (evaluador.getConceptoevaluacionCollection() == null) {
            evaluador.setConceptoevaluacionCollection(new ArrayList<Conceptoevaluacion>());
        }
        if (evaluador.getRevisaproyectoCollection() == null) {
            evaluador.setRevisaproyectoCollection(new ArrayList<Revisaproyecto>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Collection<Conceptoevaluacion> attachedConceptoevaluacionCollection = new ArrayList<Conceptoevaluacion>();
            for (Conceptoevaluacion conceptoevaluacionCollectionConceptoevaluacionToAttach : evaluador.getConceptoevaluacionCollection()) {
                conceptoevaluacionCollectionConceptoevaluacionToAttach = em.getReference(conceptoevaluacionCollectionConceptoevaluacionToAttach.getClass(), conceptoevaluacionCollectionConceptoevaluacionToAttach.getConceptoevaluacionPK());
                attachedConceptoevaluacionCollection.add(conceptoevaluacionCollectionConceptoevaluacionToAttach);
            }
            evaluador.setConceptoevaluacionCollection(attachedConceptoevaluacionCollection);
            Collection<Revisaproyecto> attachedRevisaproyectoCollection = new ArrayList<Revisaproyecto>();
            for (Revisaproyecto revisaproyectoCollectionRevisaproyectoToAttach : evaluador.getRevisaproyectoCollection()) {
                revisaproyectoCollectionRevisaproyectoToAttach = em.getReference(revisaproyectoCollectionRevisaproyectoToAttach.getClass(), revisaproyectoCollectionRevisaproyectoToAttach.getRevisaproyectoPK());
                attachedRevisaproyectoCollection.add(revisaproyectoCollectionRevisaproyectoToAttach);
            }
            evaluador.setRevisaproyectoCollection(attachedRevisaproyectoCollection);
            em.persist(evaluador);
            for (Conceptoevaluacion conceptoevaluacionCollectionConceptoevaluacion : evaluador.getConceptoevaluacionCollection()) {
                Evaluador oldEvaluadorOfConceptoevaluacionCollectionConceptoevaluacion = conceptoevaluacionCollectionConceptoevaluacion.getEvaluador();
                conceptoevaluacionCollectionConceptoevaluacion.setEvaluador(evaluador);
                conceptoevaluacionCollectionConceptoevaluacion = em.merge(conceptoevaluacionCollectionConceptoevaluacion);
                if (oldEvaluadorOfConceptoevaluacionCollectionConceptoevaluacion != null) {
                    oldEvaluadorOfConceptoevaluacionCollectionConceptoevaluacion.getConceptoevaluacionCollection().remove(conceptoevaluacionCollectionConceptoevaluacion);
                    oldEvaluadorOfConceptoevaluacionCollectionConceptoevaluacion = em.merge(oldEvaluadorOfConceptoevaluacionCollectionConceptoevaluacion);
                }
            }
            for (Revisaproyecto revisaproyectoCollectionRevisaproyecto : evaluador.getRevisaproyectoCollection()) {
                Evaluador oldEvaluadorOfRevisaproyectoCollectionRevisaproyecto = revisaproyectoCollectionRevisaproyecto.getEvaluador();
                revisaproyectoCollectionRevisaproyecto.setEvaluador(evaluador);
                revisaproyectoCollectionRevisaproyecto = em.merge(revisaproyectoCollectionRevisaproyecto);
                if (oldEvaluadorOfRevisaproyectoCollectionRevisaproyecto != null) {
                    oldEvaluadorOfRevisaproyectoCollectionRevisaproyecto.getRevisaproyectoCollection().remove(revisaproyectoCollectionRevisaproyecto);
                    oldEvaluadorOfRevisaproyectoCollectionRevisaproyecto = em.merge(oldEvaluadorOfRevisaproyectoCollectionRevisaproyecto);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findEvaluador(evaluador.getCodevaluador()) != null) {
                throw new PreexistingEntityException("Evaluador " + evaluador + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Evaluador evaluador) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evaluador persistentEvaluador = em.find(Evaluador.class, evaluador.getCodevaluador());
            Collection<Conceptoevaluacion> conceptoevaluacionCollectionOld = persistentEvaluador.getConceptoevaluacionCollection();
            Collection<Conceptoevaluacion> conceptoevaluacionCollectionNew = evaluador.getConceptoevaluacionCollection();
            Collection<Revisaproyecto> revisaproyectoCollectionOld = persistentEvaluador.getRevisaproyectoCollection();
            Collection<Revisaproyecto> revisaproyectoCollectionNew = evaluador.getRevisaproyectoCollection();
            List<String> illegalOrphanMessages = null;
            for (Conceptoevaluacion conceptoevaluacionCollectionOldConceptoevaluacion : conceptoevaluacionCollectionOld) {
                if (!conceptoevaluacionCollectionNew.contains(conceptoevaluacionCollectionOldConceptoevaluacion)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Conceptoevaluacion " + conceptoevaluacionCollectionOldConceptoevaluacion + " since its evaluador field is not nullable.");
                }
            }
            for (Revisaproyecto revisaproyectoCollectionOldRevisaproyecto : revisaproyectoCollectionOld) {
                if (!revisaproyectoCollectionNew.contains(revisaproyectoCollectionOldRevisaproyecto)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Revisaproyecto " + revisaproyectoCollectionOldRevisaproyecto + " since its evaluador field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Collection<Conceptoevaluacion> attachedConceptoevaluacionCollectionNew = new ArrayList<Conceptoevaluacion>();
            for (Conceptoevaluacion conceptoevaluacionCollectionNewConceptoevaluacionToAttach : conceptoevaluacionCollectionNew) {
                conceptoevaluacionCollectionNewConceptoevaluacionToAttach = em.getReference(conceptoevaluacionCollectionNewConceptoevaluacionToAttach.getClass(), conceptoevaluacionCollectionNewConceptoevaluacionToAttach.getConceptoevaluacionPK());
                attachedConceptoevaluacionCollectionNew.add(conceptoevaluacionCollectionNewConceptoevaluacionToAttach);
            }
            conceptoevaluacionCollectionNew = attachedConceptoevaluacionCollectionNew;
            evaluador.setConceptoevaluacionCollection(conceptoevaluacionCollectionNew);
            Collection<Revisaproyecto> attachedRevisaproyectoCollectionNew = new ArrayList<Revisaproyecto>();
            for (Revisaproyecto revisaproyectoCollectionNewRevisaproyectoToAttach : revisaproyectoCollectionNew) {
                revisaproyectoCollectionNewRevisaproyectoToAttach = em.getReference(revisaproyectoCollectionNewRevisaproyectoToAttach.getClass(), revisaproyectoCollectionNewRevisaproyectoToAttach.getRevisaproyectoPK());
                attachedRevisaproyectoCollectionNew.add(revisaproyectoCollectionNewRevisaproyectoToAttach);
            }
            revisaproyectoCollectionNew = attachedRevisaproyectoCollectionNew;
            evaluador.setRevisaproyectoCollection(revisaproyectoCollectionNew);
            evaluador = em.merge(evaluador);
            for (Conceptoevaluacion conceptoevaluacionCollectionNewConceptoevaluacion : conceptoevaluacionCollectionNew) {
                if (!conceptoevaluacionCollectionOld.contains(conceptoevaluacionCollectionNewConceptoevaluacion)) {
                    Evaluador oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion = conceptoevaluacionCollectionNewConceptoevaluacion.getEvaluador();
                    conceptoevaluacionCollectionNewConceptoevaluacion.setEvaluador(evaluador);
                    conceptoevaluacionCollectionNewConceptoevaluacion = em.merge(conceptoevaluacionCollectionNewConceptoevaluacion);
                    if (oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion != null && !oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion.equals(evaluador)) {
                        oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion.getConceptoevaluacionCollection().remove(conceptoevaluacionCollectionNewConceptoevaluacion);
                        oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion = em.merge(oldEvaluadorOfConceptoevaluacionCollectionNewConceptoevaluacion);
                    }
                }
            }
            for (Revisaproyecto revisaproyectoCollectionNewRevisaproyecto : revisaproyectoCollectionNew) {
                if (!revisaproyectoCollectionOld.contains(revisaproyectoCollectionNewRevisaproyecto)) {
                    Evaluador oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto = revisaproyectoCollectionNewRevisaproyecto.getEvaluador();
                    revisaproyectoCollectionNewRevisaproyecto.setEvaluador(evaluador);
                    revisaproyectoCollectionNewRevisaproyecto = em.merge(revisaproyectoCollectionNewRevisaproyecto);
                    if (oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto != null && !oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto.equals(evaluador)) {
                        oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto.getRevisaproyectoCollection().remove(revisaproyectoCollectionNewRevisaproyecto);
                        oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto = em.merge(oldEvaluadorOfRevisaproyectoCollectionNewRevisaproyecto);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = evaluador.getCodevaluador();
                if (findEvaluador(id) == null) {
                    throw new NonexistentEntityException("The evaluador with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Evaluador evaluador;
            try {
                evaluador = em.getReference(Evaluador.class, id);
                evaluador.getCodevaluador();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The evaluador with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Conceptoevaluacion> conceptoevaluacionCollectionOrphanCheck = evaluador.getConceptoevaluacionCollection();
            for (Conceptoevaluacion conceptoevaluacionCollectionOrphanCheckConceptoevaluacion : conceptoevaluacionCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evaluador (" + evaluador + ") cannot be destroyed since the Conceptoevaluacion " + conceptoevaluacionCollectionOrphanCheckConceptoevaluacion + " in its conceptoevaluacionCollection field has a non-nullable evaluador field.");
            }
            Collection<Revisaproyecto> revisaproyectoCollectionOrphanCheck = evaluador.getRevisaproyectoCollection();
            for (Revisaproyecto revisaproyectoCollectionOrphanCheckRevisaproyecto : revisaproyectoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Evaluador (" + evaluador + ") cannot be destroyed since the Revisaproyecto " + revisaproyectoCollectionOrphanCheckRevisaproyecto + " in its revisaproyectoCollection field has a non-nullable evaluador field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            em.remove(evaluador);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Evaluador> findEvaluadorEntities() {
        return findEvaluadorEntities(true, -1, -1);
    }

    public List<Evaluador> findEvaluadorEntities(int maxResults, int firstResult) {
        return findEvaluadorEntities(false, maxResults, firstResult);
    }

    private List<Evaluador> findEvaluadorEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Evaluador.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Evaluador findEvaluador(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Evaluador.class, id);
        } finally {
            em.close();
        }
    }

    public int getEvaluadorCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Evaluador> rt = cq.from(Evaluador.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
